home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / pcr / pcr4_4.lha / DIST / threads / ThreadsUIOStream.c < prev    next >
C/C++ Source or Header  |  1990-09-26  |  6KB  |  285 lines
  1. /* begincopyright
  2.   Copyright (c) 1988 Xerox Corporation. All rights reserved.
  3.   Use and copying of this software and preparation of derivative works based
  4.   upon this software are permitted. Any distribution of this software or
  5.   derivative works must comply with all applicable United States export
  6.   control laws. This software is made available AS IS, and Xerox Corporation
  7.   makes no warranty about the software, its performance or its conformity to
  8.   any specification. Any person obtaining a copy of this software is requested
  9.   to send their name and post office or electronic mail address to:
  10.     PCR Coordinator
  11.     Xerox PARC
  12.     3333 Coyote Hill Rd.
  13.     Palo Alto, CA
  14.   endcopyright */
  15. /*
  16.  * ThreadsUIOStream.c
  17.  *
  18.  * Demers, March 30, 1990 0:30:39 am PST
  19.  * Boehm, September 26, 1990 3:51:19 pm PDT
  20.  *
  21.  * Unix I/O for Xerox Runtime threads package, System V streams descriptors.
  22.  */
  23.  
  24.  
  25. #include "xr/ThreadsBackdoor.h"
  26. #include "xr/ThreadsSignalsPrivate.h"
  27. #include "xr/ThreadsMsgPrivate.h"
  28. #include "xr/ThreadsStatsPrivate.h"
  29. #include "xr/UIO.h"
  30. #include "xr/UIOPrivate.h"
  31. #include "xr/Errno.h"
  32.  
  33. #include <sys/types.h>
  34. #include <sys/file.h>
  35. #include <sys/fcntl.h>
  36.  
  37. #define XR_PROTECT_POLL_FROM_SIGTSTP 1    /* workaround SunOS 4.0.3 bug */
  38.  
  39. #if XR_PROTECT_POLL_FROM_SIGTSTP
  40. #   include <sys/signal.h>
  41. #endif
  42.  
  43.  
  44. #undef XR_ASSERT
  45. #define XR_ASSERT(b,s) if(!(b)) XR_Panic(s)
  46.  
  47.  
  48. /*
  49.  *
  50.  * Descriptor utilities
  51.  *
  52.  */
  53.  
  54.  
  55.  
  56. int
  57. XR_UIOIOPSetNonBlockingStream (d)
  58.     int d;
  59. {
  60. #   if STREAMS
  61.     int result, cFlags;
  62.  
  63.     if( (cFlags = fcntl(d, F_GETFL, NIL)) < 0 ) {
  64.     result = -errno;
  65.     goto Out;
  66.     }
  67.     cFlags |= FNBIO;
  68.     if( fcntl(d, F_SETFL, cFlags) < 0 ) {
  69.     result = -errno;
  70.     goto Out;
  71.     }
  72.     result = d;
  73.  
  74. Out:
  75.     return(result);
  76. #   else
  77.     XR_Panic("UIOIOPSetNonBlockingStream 0");
  78. #   endif
  79. }
  80.  
  81.  
  82.  
  83. int
  84. XR_UIOPollStream(fds, nfds, timeout, flagp)
  85.     XR_WaitReadyData fds;
  86.     int nfds;
  87.     unsigned timeout;
  88.     unsigned *flagp;
  89. {
  90. #   if STREAMS
  91.     int ans;
  92.  
  93.     if( nfds == 0 ) {
  94.         /* ??? this may be unnecessary ??? */
  95.         XR_SpinStep(timeout*1000); /* *1000 for msec to usec -mdw 8/6/89 */
  96.             errno = EINTR;
  97.             ans = (-1);
  98.     } else if( (*flagp) ) {
  99.         errno = EINTR;
  100.         ans = (-1);
  101.     } else {
  102. #           if XR_PROTECT_POLL_FROM_SIGTSTP
  103.                 int mask = sigblock(sigmask(SIGTSTP));
  104. #           endif
  105.             ans = poll(fds, nfds, timeout);
  106.             /* We assert XR_ProtectSysCall is inappropriate, since we are in */
  107.             /* an IOP.                                 */
  108.             if( ans < 0 ) switch(errno) {
  109.                 case EINTR:
  110.                 case EAGAIN:
  111.                     break;
  112.                 default:
  113.                     XR_ConsoleMsg("%? fds 0x%x nfds %d \n", fds, nfds);
  114.                     XR_Panic("UIOPollStream 0");
  115.             }
  116. #           if XR_PROTECT_POLL_FROM_SIGTSTP
  117.                 { int sav = errno; sigsetmask(mask); errno = sav; }
  118. #           endif
  119.         }
  120.     return ans;
  121. #   else
  122.     XR_Panic("UIOPollStream 1");
  123.     return(-1);
  124. #   endif
  125. }
  126.  
  127.  
  128. /*
  129.  * Exported to UIO.h
  130.  */
  131.  
  132. int
  133. XR_OpenStream (name, flags, mode)
  134.     char *name;
  135.     unsigned flags;
  136.     unsigned mode;
  137. {
  138.     return( XR_Open4(name, flags, mode, XR_FD_KIND_STREAM) );
  139. }
  140.  
  141.  
  142.  
  143. #if STREAMS
  144.  
  145. struct XR_GetMsgArgsRep {
  146.     struct strbuf *gma_ctlptr;
  147.     struct strbuf *gma_dataptr;
  148.     int *gma_flags;
  149. };
  150.  
  151. #define gma    ((struct XR_GetMsgArgsRep *)(x1))
  152.  
  153. static XR_FDE_FDC_WORKER(XR_GetMsgWorker)
  154. {
  155.     struct strbuf myCtl;
  156.     struct strbuf myData;
  157.     struct strbuf *myCtlPtr, *myDataPtr;
  158.     int myFlags;
  159.     int * myFlagsPtr;
  160.     int ans;
  161.  
  162.     if ( gma->gma_dataptr ) {
  163.         myData = *(gma->gma_dataptr);
  164.         myDataPtr = &myData;
  165.         XR_ProtectSysCall(myData.buf, myData.maxlen);
  166.     } else {
  167.         myDataPtr = 0;
  168.         XR_ProtectSysCall(0,0);
  169.     }
  170.     if ( gma->gma_ctlptr ) {
  171.         myCtl = *(gma->gma_ctlptr);
  172.         myCtlPtr = &myCtl;
  173.         XR_UnprotectSeg(myCtl.buf, myCtl.maxlen);
  174.     } else {
  175.         myCtlPtr = 0;
  176.     }
  177.     if ( gma->gma_flags ) {
  178.         myFlags = *(gma->gma_flags);
  179.         myFlagsPtr = &myFlags;
  180.     } else {
  181.         myFlagsPtr = 0;
  182.     }
  183.     ans = getmsg(fdc->fdc_index, myCtlPtr, myDataPtr, myFlagsPtr);
  184.     XR_UnprotectSysCall();
  185.     if (ans >= 0) {
  186.         if( gma->gma_ctlptr ) gma->gma_ctlptr -> len = myCtl.len;
  187.         if( gma->gma_dataptr ) gma->gma_dataptr -> len = myData.len;
  188.         if( gma->gma_flags ) *(gma->gma_flags) = myFlags;
  189.     }   
  190.     return( ans );
  191. }
  192. #undef gma
  193.  
  194. #endif
  195.  
  196.  
  197. int
  198. XR_GetMsg(fildes, ctlptr, dataptr, flags)
  199.     XR_Fildes fildes;
  200.     struct strbuf *ctlptr;
  201.     struct strbuf *dataptr;
  202.     int *flags;
  203. {
  204. #   if STREAMS
  205.     struct XR_GetMsgArgsRep args;
  206.     XR_UIOWaitReadyProc waitReadyProc;
  207.  
  208.     args.gma_ctlptr = ctlptr;
  209.     args.gma_dataptr = dataptr;
  210.     args.gma_flags = flags;
  211.     waitReadyProc = &XR_UIOInPri0WaitReadyProc;
  212.     if( (flags) && (flags[0] == RS_HIPRI) )
  213.     waitReadyProc = &XR_UIOPri0WaitReadyProc;
  214.     return(
  215.     XR_UIODoWithFDEAndFDC(
  216.         fildes,
  217.         waitReadyProc,
  218.         XR_GetMsgWorker,
  219.         ((unsigned)(&args)),
  220.         0
  221.     )
  222.     );
  223. #   else
  224.     XR_SetErrno(ENOSTR);
  225.     return(-1);
  226. #   endif
  227. }
  228.  
  229.  
  230.  
  231. #if STREAMS
  232.  
  233. struct XR_PutMsgArgsRep {
  234.     struct strbuf *pma_ctlptr;
  235.     struct strbuf *pma_dataptr;
  236.     int pma_flags;
  237. };
  238.  
  239.  
  240. #define pma    ((struct XR_PutMsgArgsRep *)(x1))
  241.  
  242. static XR_FDE_FDC_WORKER(XR_PutMsgWorker)
  243. {
  244.     int ans;
  245.  
  246.     ans = putmsg(fdc->fdc_index,
  247.         pma->pma_ctlptr, pma->pma_dataptr, pma->pma_flags);
  248.     return( ans );
  249. }
  250.  
  251. #undef pma
  252.  
  253. #endif
  254.  
  255.  
  256.  
  257. int
  258. XR_PutMsg(fildes, ctlptr, dataptr, flags)
  259.     XR_Fildes fildes;
  260.     struct strbuf *ctlptr;
  261.     struct strbuf *dataptr;
  262.     int flags;
  263. {
  264. #   if STREAMS
  265.     struct XR_PutMsgArgsRep args;
  266.  
  267.     args.pma_ctlptr = ctlptr;
  268.     args.pma_dataptr = dataptr;
  269.     args.pma_flags = flags;
  270.     return(
  271.     XR_UIODoWithFDEAndFDC(
  272.         fildes,
  273.         &XR_UIOOut0WaitReadyProc,
  274.         XR_PutMsgWorker,
  275.         ((unsigned)(&args)),
  276.         0
  277.     )
  278.     );
  279. #   else
  280.     XR_SetErrno(ENOSTR);
  281.     return(-1);
  282. #   endif
  283. }
  284.  
  285.